﻿﻿#define _CRT_SECURE_NO_WARNINGS 1


////整数转换
////整数转换。编写一个函数，确定需要改变几个位才能将整数A转成整数B。
////示例1 :
////输入：A = 29 （或者0b11101）, B = 15（或者0b01111）
////输出：2
////
////示例2 :
////输入：A = 1，B = 2
////输出：2
//
//int convertInteger(int A, int B) {
//    int count = 0;
//    for (int i = 0; i < 32; i++)
//    {
//        if (((A >> i) & 1) != ((B >> i) & 1))
//            count++;
//    }
//    return count;
//}











////至少是其他数字两倍的最大数
////给你一个整数数组 nums ，其中总是存在 唯一的 一个最大整数 。
////请你找出数组中的最大元素并检查它是否 至少是数组中每个其他数字的两倍 。如果是，则返回 最大元素的下标 ，否则返回 - 1 。
////
////示例 1：
////输入：nums = [3, 6, 1, 0]
////输出：1
////解释：6 是最大的整数，对于数组中的其他整数，6 至少是数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。
////
////示例 2：
////输入：nums = [1, 2, 3, 4]
////输出： - 1
////解释：4 没有超过 3 的两倍大，所以返回 - 1 。
////
////示例 3：
////输入：nums = [1]
////输出：0
////解释：因为不存在其他数字，所以认为现有数字 1 至少是其他数字的两倍。
//
//int dominantIndex(int* nums, int numsSize) {
//    int max = 0;
//    int sex = 0;
//    int id = 0;
//    if (nums[0] > nums[1])
//    {
//        max = nums[0];
//        sex = nums[1];
//        id = 0;
//    }
//    else
//    {
//        max = nums[1];
//        sex = nums[0];
//        id = 1;
//    }
//    for (int i = 2; i < numsSize; i++) {
//        if (sex < nums[i])
//        {
//            if (max > nums[i])
//                sex = nums[i];
//            else
//            {
//                sex = max;
//                max = nums[i];
//                id = i;
//            }
//        }
//    }
//    if (max >= sex * 2)
//        return id;
//    else
//        return -1;
//}













////两个数组的交集
////给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
////示例 1：
////输入：nums1 = [1, 2, 2, 1], nums2 = [2, 2]
////输出：[2]
////
////示例 2：
////输入：nums1 = [4, 9, 5], nums2 = [9, 4, 9, 8, 4]
////输出：[9, 4]
////解释：[4, 9] 也是可通过的
//
//int compare(const void* p1, const void* p2)
//{
//    return *(int*)p1 - *(int*)p2;
//}
//int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
//    qsort(nums1, nums1Size, sizeof(int), compare);
//    qsort(nums2, nums2Size, sizeof(int), compare);
//    int* arr = (int*)malloc(sizeof(int) * nums1Size);
//    *returnSize = 0;
//    for (int i = 0; i < nums1Size; i++)
//    {
//        if (i != 0 && nums1[i] == nums1[i - 1])
//            continue;
//        int left = 0;
//        int right = nums2Size - 1;
//        while (left <= right)
//        {
//            int mid = (left + right) / 2;
//            if (nums1[i] > nums2[mid])
//                left = mid + 1;
//            else if (nums1[i] < nums2[mid])
//                right = mid - 1;
//            else
//            {
//                arr[(*returnSize)++] = nums1[i];
//                break;
//            }
//        }
//    }
//    return arr;
//}














////自除数:
////自除数 是指可以被它包含的每一位数整除的数。
////例如，128 是一个 自除数 ，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
////自除数 不允许包含 0 。
////给定两个整数 left 和 right ，返回一个列表，列表的元素是范围 [left, right] 内所有的 自除数 。
////
////示例 1：
////输入：left = 1, right = 22
////输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
////
////示例 2:
////输入：left = 47, right = 85
////输出：[48, 55, 66, 77]
//
//int* selfDividingNumbers(int left, int right, int* returnSize) {
//    *returnSize = 0;
//    int* arr = (int*)malloc(sizeof(int) * 1000);
//
//    for (int i = left; i <= right; i++)
//    {
//        int num = i;
//        while (num)
//        {
//            int k = num % 10;
//            if (k == 0 || i % k != 0)
//            {
//                break;
//            }
//            num /= 10;
//        }
//        if (num == 0)
//            arr[(*returnSize)++] = i;
//    }
//    return arr;
//}
